home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 December / 2004-12 CHIP.iso / Internet / NVU 0.50 for Windows / nvu-0.50-win32-installer-full.exe / {app} / chrome / comm.jar / content / communicator / contentAreaUtils.js < prev    next >
Encoding:
JavaScript  |  2004-05-11  |  28.9 KB  |  878 lines
  1. /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Netscape Public License
  6.  * Version 1.1 (the "License"); you may not use this file except in
  7.  * compliance with the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/NPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is 
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1998
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *   Ben Goodger <ben@netscape.com> (Save File)
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either the GNU General Public License Version 2 or later (the "GPL"), or 
  27.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the NPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the NPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. /**
  40.  * Determine whether or not a given focused DOMWindow is in the content
  41.  * area.
  42.  **/
  43. function isContentFrame(aFocusedWindow)
  44. {
  45.   if (!aFocusedWindow)
  46.     return false;
  47.  
  48.   var focusedTop = Components.lookupMethod(aFocusedWindow, 'top')
  49.                              .call(aFocusedWindow);
  50.  
  51.   return (focusedTop == window.content);
  52. }
  53.  
  54. function urlSecurityCheck(url, doc) 
  55. {
  56.   // URL Loading Security Check
  57.   var focusedWindow = doc.commandDispatcher.focusedWindow;
  58.   var sourceURL = getContentFrameURI(focusedWindow);
  59.   const nsIScriptSecurityManager = Components.interfaces.nsIScriptSecurityManager;
  60.   var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
  61.                          .getService(nsIScriptSecurityManager);
  62.   try {
  63.     secMan.checkLoadURIStr(sourceURL, url, nsIScriptSecurityManager.STANDARD);
  64.   } catch (e) {
  65.     throw "Load of " + url + " denied.";
  66.   }
  67. }
  68.  
  69. function getContentFrameURI(aFocusedWindow)
  70. {
  71.   var contentFrame = isContentFrame(aFocusedWindow) ? aFocusedWindow : window.content;
  72.   return Components.lookupMethod(contentFrame, 'location').call(contentFrame).href;
  73. }
  74.  
  75. function getReferrer(doc)
  76. {
  77.   var focusedWindow = doc.commandDispatcher.focusedWindow;
  78.   var sourceURL = getContentFrameURI(focusedWindow);
  79.  
  80.   try {
  81.     return makeURL(sourceURL);
  82.   } catch (e) {
  83.     return null;
  84.   }
  85. }
  86.  
  87. function openNewWindowWith(url, sendReferrer) 
  88. {
  89.   urlSecurityCheck(url, document);
  90.  
  91.   // if and only if the current window is a browser window and it has a document with a character
  92.   // set, then extract the current charset menu setting from the current document and use it to
  93.   // initialize the new browser window...
  94.   var charsetArg = null;
  95.   var wintype = document.firstChild.getAttribute('windowtype');
  96.   if (wintype == "navigator:browser")
  97.     charsetArg = "charset=" + window._content.document.characterSet;
  98.  
  99.   var referrer = sendReferrer ? getReferrer(document) : null;
  100.   window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", url, charsetArg, referrer);
  101. }
  102.  
  103. function openTopBrowserWith(url)
  104. {
  105.   urlSecurityCheck(url, document);
  106.  
  107.   var windowMediator = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
  108.   var browserWin = windowMediator.getMostRecentWindow("navigator:browser");
  109.  
  110.   // if there's an existing browser window, open this url in one
  111.   if (browserWin) {
  112.     browserWin.getBrowser().loadURI(url); // Just do a normal load.
  113.     browserWin.content.focus();
  114.   }
  115.   else
  116.     window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", url, null, null);
  117. }
  118.  
  119. function openNewTabWith(url, sendReferrer, reverseBackgroundPref) 
  120. {
  121.   var browser;
  122.   try {
  123.     // if we're running in a browser window, this should work
  124.     //
  125.     browser = getBrowser();
  126.  
  127.   } catch (ex if ex instanceof ReferenceError) {
  128.  
  129.     // must be running somewhere else (eg mailnews message pane); need to
  130.     // find a browser window first
  131.     //
  132.     var windowMediator =
  133.       Components.classes["@mozilla.org/appshell/window-mediator;1"]
  134.       .getService(Components.interfaces.nsIWindowMediator);
  135.  
  136.     var browserWin = windowMediator.getMostRecentWindow("navigator:browser");
  137.  
  138.     // if there's no existing browser window, then, as long as
  139.     // we are allowed to, open this url in one and return
  140.     //
  141.     if (!browserWin) {
  142.       urlSecurityCheck(url, document);
  143.       window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", 
  144.                         url, null, referrer);
  145.       return;
  146.     }
  147.  
  148.     // otherwise, get the existing browser object
  149.     //
  150.     browser = browserWin.getBrowser();
  151.   }
  152.  
  153.   // Get the XUL document that the browser is actually contained in.
  154.   // This is needed if we are trying to load a URL from a non-navigator
  155.   // window such as the JS Console.
  156.   var browserDocument = browser.ownerDocument;
  157.  
  158.   urlSecurityCheck(url, browserDocument);
  159.  
  160.   var referrer = sendReferrer ? getReferrer(browserDocument) : null;
  161.  
  162.   // As in openNewWindowWith(), we want to pass the charset of the
  163.   // current document over to a new tab. 
  164.   var wintype = browserDocument.firstChild.getAttribute('windowtype');
  165.   var originCharset;
  166.   if (wintype == "navigator:browser") {
  167.     originCharset = window._content.document.characterSet;
  168.   }
  169.  
  170.   // open link in new tab
  171.   var tab = browser.addTab(url, referrer, originCharset); 
  172.   if (pref) {
  173.     var loadInBackground = pref.getBoolPref("browser.tabs.loadInBackground");
  174.     if (reverseBackgroundPref)
  175.       loadInBackground = !loadInBackground;
  176.  
  177.     if (!loadInBackground)
  178.       browser.selectedTab = tab;
  179.   }
  180. }
  181.  
  182. function findParentNode(node, parentNode)
  183. {
  184.   if (node && node.nodeType == Node.TEXT_NODE) {
  185.     node = node.parentNode;
  186.   }
  187.   while (node) {
  188.     var nodeName = node.localName;
  189.     if (!nodeName)
  190.       return null;
  191.     nodeName = nodeName.toLowerCase();
  192.     if (nodeName == "body" || nodeName == "html" ||
  193.         nodeName == "#document") {
  194.       return null;
  195.     }
  196.     if (nodeName == parentNode)
  197.       return node;
  198.     node = node.parentNode;
  199.   }
  200.   return null;
  201. }
  202.  
  203. // Clientelle: (Make sure you don't break any of these)
  204. //  - File    ->  Save Page/Frame As...
  205. //  - Context ->  Save Page/Frame As...
  206. //  - Context ->  Save Link As...
  207. //  - Context ->  Save Image As...
  208. //  - Shift-Click Save Link As
  209. //
  210. // Try saving each of these types:
  211. // - A complete webpage using File->Save Page As, and Context->Save Page As
  212. // - A webpage as HTML only using the above methods
  213. // - A webpage as Text only using the above methods
  214. // - An image with an extension (e.g. .jpg) in its file name, using
  215. //   Context->Save Image As...
  216. // - An image without an extension (e.g. a banner ad on cnn.com) using
  217. //   the above method. 
  218. // - A linked document using Save Link As...
  219. // - A linked document using shift-click Save Link As...
  220. //
  221. function saveURL(aURL, aFileName, aFilePickerTitleKey, aShouldBypassCache)
  222. {
  223.   saveInternal(aURL, null, aFileName, aFilePickerTitleKey, aShouldBypassCache);
  224. }
  225.  
  226. function saveFrameDocument()
  227. {
  228.   var focusedWindow = document.commandDispatcher.focusedWindow;
  229.   if (isContentFrame(focusedWindow))
  230.     saveDocument(focusedWindow.document);
  231. }
  232.  
  233. function saveDocument(aDocument)
  234. {
  235.   // In both cases here, we want to use cached data because the 
  236.   // document is currently visible. 
  237.   if (aDocument) 
  238.     saveInternal(aDocument.location.href, aDocument, false);
  239.   else
  240.     saveInternal(_content.location.href, null, false);
  241. }
  242.  
  243. function saveInternal(aURL, aDocument, 
  244.                       aFileName, aFilePickerTitleKey,
  245.                       aShouldBypassCache)
  246. {
  247.   var data = {
  248.     url: aURL,
  249.     fileName: aFileName,
  250.     filePickerTitle: aFilePickerTitleKey,
  251.     document: aDocument,
  252.     bypassCache: aShouldBypassCache,
  253.     window: window
  254.   };
  255.   var sniffer = new nsHeaderSniffer(aURL, foundHeaderInfo, data);
  256. }
  257.  
  258. function foundHeaderInfo(aSniffer, aData)
  259. {
  260.   var contentType = aSniffer.contentType;
  261.   var contentEncodingType = aSniffer.contentEncodingType;
  262.  
  263.   var shouldDecode = false;
  264.   var urlExt = null;
  265.   // Are we allowed to decode?
  266.   try {
  267.     const helperAppService =
  268.       Components.classes["@mozilla.org/uriloader/external-helper-app-service;1"].
  269.         getService(Components.interfaces.nsIExternalHelperAppService);
  270.     var url = aSniffer.uri.QueryInterface(Components.interfaces.nsIURL);
  271.     urlExt = url.fileExtension;
  272.     if (contentEncodingType &&
  273.         helperAppService.applyDecodingForExtension(urlExt,
  274.                                                    contentEncodingType)) {
  275.       shouldDecode = true;
  276.     }
  277.   }
  278.   catch (e) {
  279.   }
  280.  
  281.   var fp = makeFilePicker();
  282.   var titleKey = aData.filePickerTitle || "SaveLinkTitle";
  283.   var bundle = getStringBundle();
  284.   fp.init(window, bundle.GetStringFromName(titleKey), 
  285.           Components.interfaces.nsIFilePicker.modeSave);
  286.  
  287.   var saveMode = GetSaveModeForContentType(contentType);
  288.   var isDocument = aData.document != null && saveMode;
  289.   if (!isDocument && !shouldDecode && contentEncodingType) {
  290.     // The data is encoded, we are not going to decode it, and this is not a
  291.     // document save so we won't be doing a "save as, complete" (which would
  292.     // break if we reset the type here).  So just set our content type to
  293.     // correspond to the outermost encoding so we get extensions and the like
  294.     // right.
  295.     contentType = contentEncodingType;
  296.   }
  297.  
  298.   appendFiltersForContentType(fp, contentType, urlExt,
  299.                               isDocument ? saveMode : SAVEMODE_FILEONLY);
  300.  
  301.   const prefSvcContractID = "@mozilla.org/preferences-service;1";
  302.   const prefSvcIID = Components.interfaces.nsIPrefService;                              
  303.   var prefs = Components.classes[prefSvcContractID].getService(prefSvcIID).getBranch("browser.download.");
  304.   
  305.   const nsILocalFile = Components.interfaces.nsILocalFile;
  306.   try {
  307.     fp.displayDirectory = prefs.getComplexValue("dir", nsILocalFile);
  308.   }
  309.   catch (e) {
  310.   }
  311.  
  312.   if (isDocument) {
  313.     try {
  314.       fp.filterIndex = prefs.getIntPref("save_converter_index");
  315.     }
  316.     catch (e) {
  317.     }
  318.   }
  319.   
  320.   // Determine what the 'default' string to display in the File Picker dialog 
  321.   // should be. 
  322.   var defaultFileName = getDefaultFileName(aData.fileName, 
  323.                                            aSniffer.suggestedFileName, 
  324.                                            aSniffer.uri,
  325.                                            aData.document);
  326.   var defaultExtension = getDefaultExtension(defaultFileName, aSniffer.uri, contentType);
  327.   fp.defaultExtension = defaultExtension;
  328.   fp.defaultString = getNormalizedLeafName(defaultFileName, defaultExtension);
  329.   
  330.   if (fp.show() == Components.interfaces.nsIFilePicker.returnCancel || !fp.file)
  331.     return;
  332.  
  333.   if (isDocument) 
  334.     prefs.setIntPref("save_converter_index", fp.filterIndex);
  335.   var directory = fp.file.parent.QueryInterface(nsILocalFile);
  336.   prefs.setComplexValue("dir", nsILocalFile, directory);
  337.  
  338.   fp.file.leafName = validateFileName(fp.file.leafName);
  339.  
  340.   // XXX We depend on the following holding true in appendFiltersForContentType():
  341.   // If we should save as a complete page, the filterIndex is 0.
  342.   // If we should save as text, the filterIndex is 2.
  343.   var useSaveDocument = isDocument &&
  344.                         ((saveMode & SAVEMODE_COMPLETE_DOM && fp.filterIndex == 0) ||
  345.                          (saveMode & SAVEMODE_COMPLETE_TEXT && fp.filterIndex == 2));
  346.  
  347.   // If we're saving a document, and are saving either in complete mode or 
  348.   // as converted text, pass the document to the web browser persist component.
  349.   // If we're just saving the HTML (second option in the list), send only the URI.
  350.   var source = useSaveDocument ? aData.document : aSniffer.uri;
  351.   var persistArgs = {
  352.     source      : source,
  353.     contentType : (useSaveDocument && fp.filterIndex == 2) ? "text/plain" : contentType,
  354.     target      : makeFileURL(fp.file),
  355.     postData    : isDocument ? getPostData() : null,
  356.     bypassCache : aData.bypassCache
  357.   };
  358.   
  359.   var persist = makeWebBrowserPersist();
  360.  
  361.   // Calculate persist flags.
  362.   const nsIWBP = Components.interfaces.nsIWebBrowserPersist;
  363.   const flags = nsIWBP.PERSIST_FLAGS_NO_CONVERSION | nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
  364.   if (aData.bypassCache)
  365.     persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_BYPASS_CACHE;
  366.   else 
  367.     persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_FROM_CACHE;
  368.  
  369.   if (shouldDecode)
  370.     persist.persistFlags &= ~nsIWBP.PERSIST_FLAGS_NO_CONVERSION;
  371.     
  372.   // Create download and initiate it (below)
  373.   var dl = Components.classes["@mozilla.org/download;1"].createInstance(Components.interfaces.nsIDownload);
  374.  
  375.   if (useSaveDocument) {
  376.     // Saving a Document, not a URI:
  377.     var filesFolder = null;
  378.     if (persistArgs.contentType != "text/plain") {
  379.       // Create the local directory into which to save associated files. 
  380.       filesFolder = fp.file.clone();
  381.       
  382.       var nameWithoutExtension = filesFolder.leafName.replace(/\.[^.]*$/, "");
  383.       var filesFolderLeafName = getStringBundle().formatStringFromName("filesFolder",
  384.                                                                        [nameWithoutExtension],
  385.                                                                        1);
  386.  
  387.       filesFolder.leafName = filesFolderLeafName;
  388.     }
  389.       
  390.     var encodingFlags = 0;
  391.     if (persistArgs.contentType == "text/plain") {
  392.       encodingFlags |= nsIWBP.ENCODE_FLAGS_FORMATTED;
  393.       encodingFlags |= nsIWBP.ENCODE_FLAGS_ABSOLUTE_LINKS;
  394.       encodingFlags |= nsIWBP.ENCODE_FLAGS_NOFRAMES_CONTENT;        
  395.     }
  396.     else {
  397.       encodingFlags |= nsIWBP.ENCODE_FLAGS_ENCODE_BASIC_ENTITIES;
  398.     }
  399.  
  400.     const kWrapColumn = 80;
  401.     dl.init(aSniffer.uri, persistArgs.target, null, null, null, persist);
  402.     persist.saveDocument(persistArgs.source, persistArgs.target, filesFolder, 
  403.                          persistArgs.contentType, encodingFlags, kWrapColumn);
  404.   } else {
  405.     dl.init(source, persistArgs.target, null, null, null, persist);
  406.     var referer = getReferrer(document);
  407.     persist.saveURI(source, null, referer, persistArgs.postData, null, persistArgs.target);
  408.   }
  409. }
  410.  
  411. function nsHeaderSniffer(aURL, aCallback, aData)
  412. {
  413.   this.mCallback = aCallback;
  414.   this.mData = aData;
  415.   
  416.   this.uri = makeURL(aURL);
  417.   
  418.   this.linkChecker = Components.classes["@mozilla.org/network/urichecker;1"]
  419.     .createInstance(Components.interfaces.nsIURIChecker);
  420.   this.linkChecker.init(this.uri);
  421.  
  422.   var flags;
  423.   if (aData.bypassCache) {
  424.     flags = Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
  425.   } else {
  426.     flags = Components.interfaces.nsIRequest.LOAD_FROM_CACHE;
  427.   }
  428.   this.linkChecker.loadFlags = flags;
  429.  
  430.   // Set referrer, ignore errors
  431.   try {
  432.     var referrer = getReferrer(document);
  433.     this.linkChecker.baseChannel.QueryInterface(Components.interfaces.nsIHttpChannel).referrer = referrer;
  434.   }
  435.   catch (ex) { }
  436.  
  437.   this.linkChecker.asyncCheck(this, null);
  438. }
  439.  
  440. nsHeaderSniffer.prototype = {
  441.  
  442.   // ---------- nsISupports methods ----------
  443.   QueryInterface: function (iid) {
  444.     if (!iid.equals(Components.interfaces.nsIRequestObserver) &&
  445.         !iid.equals(Components.interfaces.nsISupports) &&
  446.         !iid.equals(Components.interfaces.nsIInterfaceRequestor)) {
  447.       throw Components.results.NS_ERROR_NO_INTERFACE;
  448.     }
  449.     return this;
  450.   },
  451.  
  452.   // ---------- nsIInterfaceRequestor methods ----------
  453.   getInterface : function(iid) {
  454.     if (iid.equals(Components.interfaces.nsIAuthPrompt)) {
  455.       // use the window watcher service to get a nsIAuthPrompt impl
  456.       var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  457.                          .getService(Components.interfaces.nsIWindowWatcher);
  458.       return ww.getNewAuthPrompter(window);
  459.     }
  460.     Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
  461.     return null;
  462.   },
  463.  
  464.   // ---------- nsIRequestObserver methods ----------
  465.   onStartRequest: function (aRequest, aContext) { },
  466.   
  467.   onStopRequest: function (aRequest, aContext, aStatus) {
  468.     try {
  469.       if (aStatus == 0) { // NS_BINDING_SUCCEEDED, so there's something there
  470.         var linkChecker = aRequest.QueryInterface(Components.interfaces.nsIURIChecker);
  471.         var channel = linkChecker.baseChannel;
  472.         this.contentType = channel.contentType;
  473.         try {
  474.           var httpChannel = channel.QueryInterface(Components.interfaces.nsIHttpChannel);
  475.           var encodedChannel = channel.QueryInterface(Components.interfaces.nsIEncodedChannel);
  476.           this.contentEncodingType = null;
  477.           // There may be content-encodings on the channel.  Multiple content
  478.           // encodings are allowed, eg "Content-Encoding: gzip, uuencode".  This
  479.           // header would mean that the content was first gzipped and then
  480.           // uuencoded.  The encoding enumerator returns MIME types
  481.           // corresponding to each encoding starting from the end, so the first
  482.           // thing it returns corresponds to the outermost encoding.
  483.           var encodingEnumerator = encodedChannel.contentEncodings;
  484.           if (encodingEnumerator && encodingEnumerator.hasMore()) {
  485.             try {
  486.               this.contentEncodingType = encodingEnumerator.getNext();
  487.             } catch (e) {
  488.             }
  489.           }
  490.           this.mContentDisposition = httpChannel.getResponseHeader("content-disposition");
  491.         }
  492.         catch (e) {
  493.         }
  494.         if (!this.contentType || this.contentType == "application/x-unknown-content-type") {
  495.           // We didn't get a type from the server.  Fall back on other type detection mechanisms
  496.           throw "Unknown Type";
  497.         }
  498.       }
  499.       else {
  500.         dump("Error saving link aStatus = 0x" + aStatus.toString(16) + "\n");
  501.         var bundle = getStringBundle();
  502.         var errorTitle = bundle.GetStringFromName("saveLinkErrorTitle");
  503.         var errorMsg = bundle.GetStringFromName("saveLinkErrorMsg");
  504.         const promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService(Components.interfaces.nsIPromptService);
  505.         promptService.alert(this.mData.window, errorTitle, errorMsg);
  506.         return;
  507.       }
  508.     }
  509.     catch (e) {
  510.       if (this.mData.document) {
  511.         this.contentType = this.mData.document.contentType;
  512.       } else {
  513.         var type = getMIMETypeForURI(this.uri);
  514.         if (type)
  515.           this.contentType = type;
  516.       }
  517.     }
  518.     this.mCallback(this, this.mData);
  519.   },
  520.  
  521.   // ------------------------------------------------
  522.  
  523.   get promptService()
  524.   {
  525.     var promptSvc;
  526.     try {
  527.       promptSvc = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService();
  528.       promptSvc = promptSvc.QueryInterface(Components.interfaces.nsIPromptService);
  529.     }
  530.     catch (e) {}
  531.     return promptSvc;
  532.   },
  533.  
  534.   get suggestedFileName()
  535.   {
  536.     var fileName = "";
  537.  
  538.     if ("mContentDisposition" in this) {
  539.       const mhpContractID = "@mozilla.org/network/mime-hdrparam;1"
  540.       const mhpIID = Components.interfaces.nsIMIMEHeaderParam;
  541.       const mhp = Components.classes[mhpContractID].getService(mhpIID);
  542.       var dummy = { value: null }; // To make JS engine happy.
  543.       var charset = getCharsetforSave(null);
  544.  
  545.       try {
  546.         fileName = mhp.getParameter(this.mContentDisposition, "filename", charset, true, dummy);
  547.       } 
  548.       catch (e) {
  549.         try {
  550.           fileName = mhp.getParameter(this.mContentDisposition, "name", charset, true, dummy);
  551.         }
  552.         catch (e) {
  553.         }
  554.       }
  555.     }
  556.  
  557.     fileName = fileName.replace(/^"|"$/g, "");
  558.     return fileName;
  559.   }
  560. };
  561.  
  562. // We have no DOM, and can only save the URL as is.
  563. const SAVEMODE_FILEONLY      = 0x00;
  564. // We have a DOM and can save as complete.
  565. const SAVEMODE_COMPLETE_DOM  = 0x01;
  566. // We have a DOM which we can serialize as text.
  567. const SAVEMODE_COMPLETE_TEXT = 0x02;
  568.  
  569. // If we are able to save a complete DOM, the 'save as complete' filter
  570. // must be the first filter appended.  The 'save page only' counterpart
  571. // must be the second filter appended.  And the 'save as complete text'
  572. // filter must be the third filter appended.
  573. function appendFiltersForContentType(aFilePicker, aContentType, aFileExtension, aSaveMode)
  574. {
  575.   var bundle = getStringBundle();
  576.   // The bundle name for saving only a specific content type.
  577.   var bundleName;
  578.   // The corresponding filter string for a specific content type.
  579.   var filterString;
  580.  
  581.   // XXX all the cases that are handled explicitly here MUST be handled
  582.   // in GetSaveModeForContentType to return a non-fileonly filter.
  583.   switch (aContentType) {
  584.   case "text/html":
  585.     bundleName   = "WebPageHTMLOnlyFilter";
  586.     filterString = "*.htm; *.html";
  587.     break;
  588.  
  589.   case "application/xhtml+xml":
  590.     bundleName   = "WebPageXHTMLOnlyFilter";
  591.     filterString = "*.xht; *.xhtml";
  592.     break;
  593.  
  594.   case "text/xml":
  595.   case "application/xml":
  596.     bundleName   = "WebPageXMLOnlyFilter";
  597.     filterString = "*.xml";
  598.     break;
  599.  
  600.   default:
  601.     if (aSaveMode != SAVEMODE_FILEONLY) {
  602.       throw "Invalid save mode for type '" + aContentType + "'";
  603.     }
  604.  
  605.     var mimeInfo = getMIMEInfoForType(aContentType, aFileExtension);
  606.     if (mimeInfo) {
  607.       
  608.       var extEnumerator = mimeInfo.getFileExtensions();
  609.  
  610.       var extString = "";
  611.       while (extEnumerator.hasMore()) {
  612.         var extension = extEnumerator.getNext();
  613.         if (extString)
  614.           extString += "; ";    // If adding more than one extension,
  615.                                 // separate by semi-colon
  616.         extString += "*." + extension;
  617.       }
  618.         
  619.       if (extString) {
  620.         aFilePicker.appendFilter(mimeInfo.Description, extString);
  621.       }
  622.     }
  623.  
  624.     break;
  625.   }
  626.  
  627.   if (aSaveMode & SAVEMODE_COMPLETE_DOM) {
  628.     aFilePicker.appendFilter(bundle.GetStringFromName("WebPageCompleteFilter"), filterString);
  629.     // We should always offer a choice to save document only if
  630.     // we allow saving as complete.
  631.     aFilePicker.appendFilter(bundle.GetStringFromName(bundleName), filterString);
  632.   }
  633.  
  634.   if (aSaveMode & SAVEMODE_COMPLETE_TEXT) {
  635.     aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterText);
  636.   }
  637.  
  638.   // Always append the all files (*) filter
  639.   aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll);
  640. } 
  641.  
  642. function getPostData()
  643. {
  644.   try {
  645.     var sessionHistory = getWebNavigation().sessionHistory;
  646.     return sessionHistory.getEntryAtIndex(sessionHistory.index, false)
  647.                          .QueryInterface(Components.interfaces.nsISHEntry)
  648.                          .postData;
  649.   }
  650.   catch (e) {
  651.   }
  652.   return null;
  653. }
  654.  
  655. function getStringBundle()
  656. {
  657.   const bundleURL = "chrome://communicator/locale/contentAreaCommands.properties";
  658.   
  659.   const sbsContractID = "@mozilla.org/intl/stringbundle;1";
  660.   const sbsIID = Components.interfaces.nsIStringBundleService;
  661.   const sbs = Components.classes[sbsContractID].getService(sbsIID);
  662.   
  663.   const lsContractID = "@mozilla.org/intl/nslocaleservice;1";
  664.   const lsIID = Components.interfaces.nsILocaleService;
  665.   const ls = Components.classes[lsContractID].getService(lsIID);
  666.   var appLocale = ls.getApplicationLocale();
  667.   return sbs.createBundle(bundleURL, appLocale);    
  668. }
  669.  
  670. function makeWebBrowserPersist()
  671. {
  672.   const persistContractID = "@mozilla.org/embedding/browser/nsWebBrowserPersist;1";
  673.   const persistIID = Components.interfaces.nsIWebBrowserPersist;
  674.   return Components.classes[persistContractID].createInstance(persistIID);
  675. }
  676.  
  677. function makeURL(aURL)
  678. {
  679.   var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  680.                 .getService(Components.interfaces.nsIIOService);
  681.   return ioService.newURI(aURL, null, null);
  682. }
  683.  
  684. function makeFileURL(aFile)
  685. {
  686.   var ioService = Components.classes["@mozilla.org/network/io-service;1"]
  687.                 .getService(Components.interfaces.nsIIOService);
  688.   return ioService.newFileURI(aFile);
  689. }
  690.  
  691. function makeFilePicker()
  692. {
  693.   const fpContractID = "@mozilla.org/filepicker;1";
  694.   const fpIID = Components.interfaces.nsIFilePicker;
  695.   return Components.classes[fpContractID].createInstance(fpIID);
  696. }
  697.  
  698. function getMIMEService()
  699. {
  700.   const mimeSvcContractID = "@mozilla.org/mime;1";
  701.   const mimeSvcIID = Components.interfaces.nsIMIMEService;
  702.   const mimeSvc = Components.classes[mimeSvcContractID].getService(mimeSvcIID);
  703.   return mimeSvc;
  704. }
  705.  
  706. function getMIMETypeForURI(aURI)
  707. {
  708.   try {  
  709.     return getMIMEService().getTypeFromURI(aURI);
  710.   }
  711.   catch (e) {
  712.   }
  713.   return null;
  714. }
  715.  
  716. function getMIMEInfoForType(aMIMEType, aExtension)
  717. {
  718.   try {  
  719.     return getMIMEService().getFromTypeAndExtension(aMIMEType, aExtension);
  720.   }
  721.   catch (e) {
  722.   }
  723.   return null;
  724. }
  725.  
  726. function getDefaultFileName(aDefaultFileName, aNameFromHeaders, aDocumentURI, aDocument)
  727. {
  728.   if (aNameFromHeaders)
  729.     // 1) Use the name suggested by the HTTP headers
  730.     return validateFileName(aNameFromHeaders);
  731.  
  732.   try {
  733.     var url = aDocumentURI.QueryInterface(Components.interfaces.nsIURL);
  734.     if (url.fileName != "") {
  735.       // 2) Use the actual file name, if present
  736.       return validateFileName(decodeURIComponent(url.fileName));
  737.     }
  738.   } catch (e) {
  739.     try {
  740.       // the file name might be non ASCII
  741.       // try unescape again with a characterSet
  742.       var textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
  743.                                    .getService(Components.interfaces.nsITextToSubURI);
  744.       var charset = getCharsetforSave(aDocument);
  745.       return validateFileName(textToSubURI.unEscapeURIForUI(charset, url.fileName));
  746.     } catch (e) {
  747.       // This is something like a wyciwyg:, data:, and so forth
  748.       // URI... no usable filename here.
  749.     }
  750.   }
  751.   
  752.   if (aDocument) {
  753.     var docTitle = GenerateValidFilename(aDocument.title, "");
  754.  
  755.     if (docTitle) {
  756.       // 3) Use the document title
  757.       return docTitle;
  758.     }
  759.   }
  760.   
  761.   if (aDefaultFileName)
  762.     // 4) Use the caller-provided name, if any
  763.     return validateFileName(aDefaultFileName);
  764.  
  765.   // 5) If this is a directory, use the last directory name
  766.   var path = aDocumentURI.path.match(/\/([^\/]+)\/$/);
  767.   if (path && path.length > 1) {
  768.       return validateFileName(path[1]);
  769.   }
  770.  
  771.   try {
  772.     if (aDocumentURI.host)
  773.       // 6) Use the host.
  774.       return aDocumentURI.host;
  775.   } catch (e) {
  776.     // Some files have no information at all, like Javascript generated pages
  777.   }
  778.   try {
  779.     // 7) Use the default file name
  780.     return getStringBundle().GetStringFromName("DefaultSaveFileName");
  781.   } catch (e) {
  782.     //in case localized string cannot be found
  783.   }
  784.   // 8) If all else fails, use "index"
  785.   return "index";
  786. }
  787.  
  788. function getNormalizedLeafName(aFile, aDefaultExtension)
  789. {
  790.   if (!aDefaultExtension)
  791.     return aFile;
  792.   
  793.   // Fix up the file name we're saving to to include the default extension
  794.   const stdURLContractID = "@mozilla.org/network/standard-url;1";
  795.   const stdURLIID = Components.interfaces.nsIURL;
  796.   var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
  797.   url.filePath = aFile;
  798.   
  799.   if (url.fileExtension != aDefaultExtension) {
  800.     return aFile + "." + aDefaultExtension;
  801.   }
  802.  
  803.   return aFile;
  804. }
  805.  
  806. function getDefaultExtension(aFilename, aURI, aContentType)
  807. {
  808.   if (aContentType == "text/plain" || aContentType == "application/octet-stream" || aURI.scheme == "ftp")
  809.     return "";   // temporary fix for bug 120327
  810.  
  811.   // First try the extension from the filename
  812.   const stdURLContractID = "@mozilla.org/network/standard-url;1";
  813.   const stdURLIID = Components.interfaces.nsIURL;
  814.   var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
  815.   url.filePath = aFilename;
  816.  
  817.   var ext = url.fileExtension;
  818.  
  819.   // This mirrors some code in nsExternalHelperAppService::DoContent
  820.   // Use the filename first and then the URI if that fails
  821.   
  822.   var mimeInfo = getMIMEInfoForType(aContentType, ext);
  823.  
  824.   if (ext && mimeInfo && mimeInfo.ExtensionExists(ext)) {
  825.     return ext;
  826.   }
  827.   
  828.   // Well, that failed.  Now try the extension from the URI
  829.   var urlext;
  830.   try {
  831.     url = aURI.QueryInterface(Components.interfaces.nsIURL);
  832.     urlext = url.fileExtension;
  833.   } catch (e) {
  834.   }
  835.  
  836.   if (urlext && mimeInfo && mimeInfo.ExtensionExists(urlext)) {
  837.     return urlext;
  838.   }
  839.   else {
  840.     try {
  841.       return mimeInfo.primaryExtension;
  842.     }
  843.     catch (e) {
  844.       // Fall back on the extensions in the filename and URI for lack
  845.       // of anything better.
  846.       return ext || urlext;
  847.     }
  848.   }
  849. }
  850.  
  851. function GetSaveModeForContentType(aContentType)
  852. {
  853.   var saveMode = SAVEMODE_FILEONLY;
  854.   switch (aContentType) {
  855.   case "text/html":
  856.   case "application/xhtml+xml":
  857.     saveMode |= SAVEMODE_COMPLETE_TEXT;
  858.     // Fall through
  859.   case "text/xml":
  860.   case "application/xml":
  861.     saveMode |= SAVEMODE_COMPLETE_DOM;
  862.     break;
  863.   }
  864.  
  865.   return saveMode;
  866. }
  867.  
  868. function getCharsetforSave(aDocument)
  869. {
  870.   if (aDocument)
  871.     return aDocument.characterSet;
  872.  
  873.   if (document.commandDispatcher.focusedWindow)
  874.     return document.commandDispatcher.focusedWindow.document.characterSet;
  875.  
  876.   return  window._content.document.characterSet;
  877. }
  878.